/**
 * functions.c
 *
 * Funções básicas para o funcionamento da shell
 */

#include "../meushell.h"
#include<stdio.h>
#include <termios.h>
#include<string.h>
#include <sys/ioctl.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/wait.h>
#include<unistd.h>

extern char host[HOST_S],
         pronto[PRONTO_S],
         shell[SHELL_S],
         dta[DTA_S],
         caminho[CAMINHO_S];
extern char *args[ARGS_S];

/**
 * Limpa a tela
 *
 */
void limpa()
{
    fprintf(stdout, "\033[2J");
    fprintf(stdout, "\033[1;1H");
}

/**
 * Limpa argumentos
 *
 */
void limpaargs()
{
    int index = 0;
    
    for(;args[index] != NULL; index++){
        args[index] = NULL;
        free(args[index]);
    }
}

/**
 * Verifica qual o caminho para o executavel, caso exista o caminho é alterado
 *
 * retorna 1 em caso de sucesso e 0 em caso de falha
 */
int verifica_caminho(char *exec)
{
    int file, i;
    int index = 0;
    char *caminhotemp;
    strcpy(caminhotemp, caminho);
    char *subcaminho[20];
    char *aux = strtok(caminhotemp, ":");
    
    while(aux != NULL){
        if(subcaminho[index] == NULL)
            subcaminho[index] = (char *)malloc(sizeof(char) * CAMINHO_S);
        else
            subcaminho[index][0] = '\0';
        
        strcpy(subcaminho[index++], aux);
        aux = strtok(NULL, ":");
    }
    for(i=0; i<index; i++){
        if( file = fopen(strcat(subcaminho[i], exec), "r") > 0){
            strcpy(exec, subcaminho[i]);
            return 1;
        }
    }
    return 0;
}

/**
 * funções amb
 * imprime ou altera o valor das variáveis de ambiente
 */
// Se tiver um '=' no args[1] tenta atribuir o valor
void ambaction(){
    if(strchr(args[1], '=')){
        int i;
        char atrib[2][128];
        char *subst = strtok(args[1], "=");
        strcpy(atrib[0], subst);
        
        subst = strtok(NULL, "=");
        strcpy(atrib[1], subst);
        
        for(i=2; args[i] != NULL; i++){
            strcat(atrib[1], " ");
            strcat(atrib[1], args[i]);
        }
        
        if(strcmp(atrib[0], "CAMINHO")==0){
            strcpy(caminho, atrib[1]);
        }
        else if(strcmp(atrib[0], "DTA")==0){
            strcpy(dta, atrib[1]);
        }
        else if(strcmp(atrib[0], "HOST")==0){
            strcpy(host, atrib[1]);
        }
        else if(strcmp(atrib[0], "PRONTO")==0){
            strcpy(pronto, atrib[1]);
        }
        else if(strcmp(atrib[0], "SHELL")==0){
            strcpy(shell, atrib[1]);
        }
        else {
            printf("variável %s inexistente\n", atrib[0]);
        }
    }
    // imprime o valor da variavel args[1]
    else if(strcmp(args[1], "$CAMINHO")==0){
        printf("%s\n", caminho);
    }
    else if(strcmp(args[1], "$DTA")==0){
        printf("%s\n", dta);
    }
    else if(strcmp(args[1], "$HOST")==0){
        printf("%s\n", host);
    }
    else if(strcmp(args[1], "$PRONTO")==0){
        printf("%s\n", pronto);
    }
    else if(strcmp(args[1], "$SHELL")==0){
        printf("%s\n", shell);
    }
    else {
        printf("variável %s inexistente\n", args[1]);
    }
}

/**
 * verifica se o comando foi digitado anteriormente
 */
int verificaReplica(char *comando){

	FILE *fptr;
	int i;
	char ultimoItem[1024];

	fptr = fopen(".meushell.hst", "r");

	if(fptr == NULL){
		printf("Deu merda no arquivo.\n");
		exit(1);
	}

	while (!feof(fptr)){
		i = 0;

		do{
			fscanf(fptr, "%c", &ultimoItem[i]);
			if(feof(fptr))
				break;
			i++;

		}while(ultimoItem[i-1] != '\n');

		if (i > 1){
			ultimoItem[i-1] = '\0' ;
		}
	}
	fclose(fptr);
	return strcmp(comando, ultimoItem);

}

/**
 * separa uma strin em substring com base no separador
 * passado por parametro
 */
char **split( char *string, const char *sep )
{
    char *haystack     = ( char * )malloc( strlen( string ) * sizeof( char ) );
    char **result      = ( char ** )malloc( 4096 * sizeof( char * ) );
    char *resultString = NULL;
    int i = 0;

    strcpy( haystack, string );

    resultString = strtok( haystack, sep );
    
    if( resultString == NULL )
        printf( "%s: inválido\n", haystack );
    
    while( resultString != NULL )
    {
        result[i] = resultString;
        resultString   = strtok( NULL, sep );
        i++;
    }

    result[i] = NULL;

    return result;
}

/**
 * Retorna o tamanho do vetor
 *
 */
int getArrayLength( char **array )
{
    int size = 0;
    
    while( array[size] != NULL )
    size++;
    
    return size;
}

/**
 * pega as dimensões da janela
 */
void tamanhoJanela(int *l, int *c){
	struct winsize w;
	ioctl(0, TIOCGWINSZ, &w);
	*l = w.ws_row;
	*c = w.ws_col;
}

/**
 * le um caractere sem o uso do enter
 *
 */
char getch(void) {
    char buf = 0;
    struct termios old = {0};
    if (tcgetattr(0, &old) < 0)
        perror("tcsetattr()");
    old.c_lflag &= ~ICANON;
    old.c_lflag &= ~ECHO;
    old.c_cc[VMIN] = 1;
    old.c_cc[VTIME] = 0;
    if (tcsetattr(0, TCSANOW, &old) < 0)
        perror("tcsetattr ICANON");
    if (read(0, &buf, 1) < 0)
        perror ("read()");
    old.c_lflag |= ICANON;
    old.c_lflag |= ECHO;
    if (tcsetattr(0, TCSADRAIN, &old) < 0)
        perror ("tcsetattr ~ICANON");
    return (buf);
}

